home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / procssng / ccs / ccs-11tl.lha / lbl / sun / rlelib / buildmap.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-15  |  4.5 KB  |  164 lines
  1. /*
  2.  * This software is copyrighted as noted below.  It may be freely copied,
  3.  * modified, and redistributed, provided that the copyright notice is 
  4.  * preserved on all copies.
  5.  * 
  6.  * There is no warranty or other guarantee of fitness for this software,
  7.  * it is provided solely "as is".  Bug reports or fixes may be sent
  8.  * to the author, who may or may not act on them as he desires.
  9.  *
  10.  * You may not include this software in a program or other software product
  11.  * without supplying the source, or without informing the end-user that the 
  12.  * source is available for no extra charge.
  13.  *
  14.  * If you modify this software, you should include a notice giving the
  15.  * name of the person performing the modification, the date of modification,
  16.  * and the reason for such modification.
  17.  */
  18. /* 
  19.  * buildmap.c - Build a color map from the RLE file color map.
  20.  * 
  21.  * Author:    Spencer W. Thomas
  22.  *         Computer Science Dept.
  23.  *         University of Utah
  24.  * Date:    Sat Jan 24 1987
  25.  * Copyright (c) 1987, University of Utah
  26.  */
  27.  
  28. #include <stdio.h>
  29. #include <rle.h>
  30. #include <math.h>
  31.  
  32. #ifdef VOID_STAR
  33. void *malloc();
  34. #else
  35. char *malloc();
  36. #endif
  37. void free();
  38.  
  39. /*****************************************************************
  40.  * TAG( buildmap )
  41.  * 
  42.  * Returns a color map that can easily be used to map the pixel values in
  43.  * an RLE file.  Map is built from the color map in the input file.
  44.  * Inputs:
  45.  *     the_hdr:    rle_hdr structure containing color map.
  46.  *    minmap:        Minimum number of channels in output map.
  47.  *    orig_gamma:    Adjust color map for this image gamma value
  48.  *            (1.0 means no adjustment).
  49.  *    new_gamma:    Gamma of new display.
  50.  * Outputs:
  51.  *     Returns an array of pointers to arrays of rle_pixels.  The array
  52.  *    of pointers contains max(ncolors, ncmap) elements, each 
  53.  *    array of pixels contains 2^cmaplen elements.  The pixel arrays
  54.  *    should be considered read-only.
  55.  * Assumptions:
  56.  *     [None]
  57.  * Algorithm:
  58.  *    Ensure that there are at least ncolors rows in the map, and
  59.  *    that each has at least 256 elements in it (largest map that can
  60.  *    be addressed by an rle_pixel).
  61.  */
  62. rle_pixel **
  63. buildmap( the_hdr, minmap, orig_gamma, new_gamma )
  64. rle_hdr *the_hdr;
  65. int minmap;
  66. double orig_gamma;
  67. double new_gamma;
  68. {
  69.     rle_pixel ** cmap, * gammap;
  70.     double gamma;
  71.     register int i, j;
  72.     int maplen, cmaplen, nmap;
  73.  
  74.     if ( the_hdr->ncmap == 0 )    /* make identity map */
  75.     {
  76.     nmap = (minmap < the_hdr->ncolors) ? the_hdr->ncolors : minmap;
  77.     cmap = (rle_pixel **)malloc( nmap * sizeof(rle_pixel *) );
  78.     cmap[0] = (rle_pixel *)malloc( nmap * 256 * sizeof(rle_pixel) );
  79.     for ( j = 1; j < nmap; j++ )
  80.         cmap[j] = cmap[j-1] + 256;
  81.     for ( i = 0; i < 256; i++ )
  82.         for ( j = 0; j < nmap; j++ )
  83.         cmap[j][i] = i;
  84.     maplen = 256;
  85.     }
  86.     else            /* make map from the_hdr */
  87.     {
  88.     /* Map is at least 256 long */
  89.     cmaplen = (1 << the_hdr->cmaplen);
  90.     if ( cmaplen < 256 )
  91.         maplen = 256;
  92.     else
  93.         maplen = cmaplen;
  94.  
  95.     /* Nmap is max( minmap, the_hdr->ncmap, the_hdr->ncolors ). */
  96.     nmap = minmap;
  97.     if ( nmap < the_hdr->ncmap )
  98.         nmap = the_hdr->ncmap;
  99.     if ( nmap < the_hdr->ncolors )
  100.         nmap = the_hdr->ncolors;
  101.     
  102.     /* Allocate memory for the map and secondary pointers. */
  103.     cmap = (rle_pixel **)malloc( nmap * sizeof(rle_pixel *) );
  104.     cmap[0] = (rle_pixel *)malloc( nmap * maplen * sizeof(rle_pixel) );
  105.     for ( i = 1; i < nmap; i++ )
  106.         cmap[i] = cmap[0] + i * maplen;
  107.     
  108.     /* Fill it in. */
  109.     for ( i = 0; i < maplen; i++ )
  110.     {
  111.         for ( j = 0; j < the_hdr->ncmap; j++ )
  112.         if ( i < cmaplen )
  113.             cmap[j][i] = the_hdr->cmap[j*cmaplen + i] >> 8;
  114.         else
  115.             cmap[j][i] = i;
  116.         for ( ; j < nmap; j++ )
  117.         cmap[j][i] = cmap[j-i][i];
  118.     }
  119.     }
  120.     
  121.     /* Gamma compensate if requested */
  122.     if ( orig_gamma == 0 )
  123.     {
  124.     char *v;
  125.     if ( (v = rle_getcom( "image_gamma", the_hdr )) != NULL )
  126.     {
  127.         orig_gamma = atof( v );
  128.         /* Protect against bogus information */
  129.         if ( orig_gamma == 0.0 )
  130.         orig_gamma = 1.0;
  131.         else
  132.         orig_gamma = 1.0 / orig_gamma;
  133.     }
  134.     else if ( (v = rle_getcom( "display_gamma", the_hdr )) != NULL)
  135.     {
  136.         orig_gamma = atof( v );
  137.         /* Protect */
  138.         if ( orig_gamma == 0.0 )
  139.         orig_gamma = 1.0;
  140.     }
  141.     else
  142.         orig_gamma = 1.0;
  143.     }
  144.  
  145.     /* Now, compensate for the gamma of the new display, too. */
  146.     if ( new_gamma != 0.0 )
  147.     gamma = orig_gamma / new_gamma;
  148.     else
  149.     gamma = orig_gamma;
  150.  
  151.     if ( gamma != 1.0 )
  152.     {
  153.     gammap = (rle_pixel *)malloc( 256 * sizeof(rle_pixel) );
  154.     for ( i = 0; i < 256; i++ )
  155.         gammap[i] = (int)(0.5 + 255.0 * pow( i / 255.0, gamma ));
  156.     for ( i = 0; i < nmap; i++ )
  157.         for ( j = 0; j < maplen; j++ )
  158.         cmap[i][j] = gammap[cmap[i][j]];
  159.     free( gammap );
  160.     }
  161.  
  162.     return cmap;
  163. }
  164.